/*
 * QSPI.c
 *
 *  Created on: 2022年1月12日
 *  Author: Laputa
 */

#include "QSPI.h"
#include "bsp.h"
//#include "app.h"
//#include "EPORT.h"



//#define CS 1   //0 硬件片选，1 软件片选
//#define QSPI_SS_LOW(a)   (*(volatile unsigned char *)(0x40010000+0x0021)) &= ~(1<<((((int)a-0x60000000)>>28)));
//#define QSPI_SS_HIGH(a)  (*(volatile unsigned char *)(0x40010000+0x0021)) |= (1<<((((int)a-0x60000000)>>28)));


void QSPI_Standard_Init(qspi* t)  //标准单线模式
{
	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI0

	t->U32_CTRLR0.SPI_FRF = 0;  //标准SPI模式
	t->U32_CTRLR0.CFS = 0;		//
	t->U32_CTRLR0.SSTE = 0;		//
	t->U32_CTRLR0.SRL = 0;		//
	t->U32_CTRLR0.SLV_OE = 0;	//
	t->U32_CTRLR0.TMOD = 0;		//TX_AND_RX
	t->U32_CTRLR0.SCPOL = 0;	//闲置为高电平
	t->U32_CTRLR0.SCPH = 0;		//数据抓取从一个时钟周期的第二个边沿开始
	t->U32_CTRLR0.FRF = 0;		//摩托罗拉SPI模式
	t->U32_CTRLR0.DFS = 0x07;   //数据格式为8bit

//	LTPrintf("CTRLR0:%x \r\n",t->U32_CTRLR0);

	t->U32_CTRLR1.NDF = 0;		//传输数目
	t->U32_BAUDR.SCKDV = 4;  	//时钟频率
	t->U32_TXFTLR.TXFTHR = 0;   //转移开始FIFO等级
	t->U32_TXFTLR.TFT = 4;		//传输FIFO阈值
	t->U32_RXFTLR.RFT = 4;		//接受FIFO阈值

	t->U32_RXSDR.SE = 0;		//
	t->U32_RXSDR.RSD = 0;		//接收数据采样延迟

	t->U32_SPICTRLR0.CLK_STRETCH_EN = 0; //SPI时钟增强
	t->U32_SPICTRLR0.WAIT_CYCLES = 0;	 //等待周期
	t->U32_SPICTRLR0.INST_L = 0x02;		 //命令长度
	t->U32_SPICTRLR0.ADDR_L = 0x06;		 //地址长度
	t->U32_SPICTRLR0.TRANS_TYPE = 0;   //命令和地址的传输类型

	t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI0
//	Delay_Ms(1000);
//	LTPrintf("SR:%x \r\n",t->U32_SR);

//------片选部分-------

	if(t == QSPI0)
	{
		CCM->U32_QSPIGPIOCR.QSPI0_SS_GPIOPEN = 1; //片选软件控制
		CCM->U32_QSPIGPIOCR.QSPI0_SS_PUE = 1;//片选上拉
		CCM->U32_QSPIGPIOCR.QSPI0_SS_OBE = 1;//输出模式
	}
	else if(t == QSPI1)
	{
		CCM->U32_QSPIGPIOCR.QSPI1_SS_GPIOPEN = 1; //片选软件控制
		CCM->U32_QSPIGPIOCR.QSPI1_SS_PUE = 1;//片选上拉
		CCM->U32_QSPIGPIOCR.QSPI1_SS_OBE = 1;//输出模式
	}
	else if(t == QSPI2)
	{
		CCM->U32_QSPIGPIOCR.QSPI2_SS_GPIOPEN = 1; //片选软件控制
		CCM->U32_QSPIGPIOCR.QSPI2_SS_PUE = 1;//片选上拉
		CCM->U32_QSPIGPIOCR.QSPI2_SS_OBE = 1;//输出模式
	}

	QSPI_SS_HIGH((int)t);

}


//void QSPI_STD_RX_DMA(unsigned char* p)
//{
//	DMA_CTL->U32_SERQR.SERQ |= 1<<1;        //开启QSPI0_RX_DMA_Channel 请求
//
//	DMA_TCD_01->saddr = (UINT32)(&QSPI0->DR);      //源地址
//	DMA_TCD_01->U32_Word1.ssize = 0;		 //源地址传输长度 8bit
//	DMA_TCD_01->U32_Word5.doff = 0;
//	DMA_TCD_01->U32_Word1.dsize = 0;		 //目的地址传输长度 8bit
//	DMA_TCD_01->U32_Word1.soff = 0;
//
//	DMA_TCD_01->nbytes = 256;			 //传输数目
//	DMA_TCD_01->slastr = 0;				 //
//	DMA_TCD_01->daddr = (UINT32)p;		 //目的地址
//
////	DMA_TCD_01->U32_Word7.biter = 1;
////	DMA_TCD_01->U32_Word5.citer = 1;
//	DMA_TCD_01->dlast_sgar = 0;
//
//	LTPrintf("Saddr:%x \r\n",DMA_TCD_01->saddr);
//	LTPrintf("Daddr:%x \r\n",DMA_TCD_01->daddr);
//}
//
//void QSPI_STD_TX_DMA(unsigned char* p)
//{
//	DMA_CTL->U32_SERQR.SERQ |= 1<<2;        //开启QSPI0_TX_DMA_Channel 请求
//
//
//	DMA_TCD_02->saddr = (UINT32)p;      //源地址
//	DMA_TCD_02->U32_Word1.ssize = 0;		 //源地址传输长度 8bit
//	DMA_TCD_02->U32_Word5.doff = 0;
//	DMA_TCD_02->U32_Word1.dsize = 0;		 //目的地址传输长度 8bit
//	DMA_TCD_02->U32_Word1.soff = 0;
//
//	DMA_TCD_02->nbytes = 256;			 //传输数目
//	DMA_TCD_02->slastr = 0;				 //
//	DMA_TCD_02->daddr = (UINT32)(&QSPI0->DR);		 //目的地址
//
////	DMA_TCD_02->U32_Word7.biter = 1;
////	DMA_TCD_02->U32_Word5.citer = 1;
//	DMA_TCD_02->dlast_sgar = 0;
//}
//
UINT16 QSPI_ReadWriteByte(qspi* t,UINT16 TxData)
{
//	LTPrintf("RWtest\r\n");
	while(t->U32_SR.TFE == 0)	//等待TX FIFO空
	{
		__asm("nop");
	}
	t->DR = TxData;	 	  		//发送一个byte
	while( t->U32_SR.RFNE == 0) 	//等RX FIFO非空，待接收完一个byte
	{
		__asm("nop");
	}
	return t->DR;          		//返回收到的数据
}


UINT16 W25Q_ReadID_STD(qspi* t)
{
	UINT16 temp;
	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x90);
	QSPI_ReadWriteByte(t,0x00);
	QSPI_ReadWriteByte(t,0x00);
	QSPI_ReadWriteByte(t,0x00);
	temp = QSPI_ReadWriteByte(t,0xFF);
	temp<<=8;
	temp |= QSPI_ReadWriteByte(t,0xFF)&0xFF;
	QSPI_SS_HIGH((int)t);
	return temp;
}

UINT8 W25Q_ReadSR_STD(qspi* t)   //读取W25QXX的状态寄存器
{
	UINT8 byte=0;
	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x05);
	byte=QSPI_ReadWriteByte(t,0Xff);
	QSPI_SS_HIGH((int)t);
	return byte;
}


void W25Q_Write_Enable_STD(qspi* t)
{
	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x06);
    QSPI_SS_HIGH((int)t);
}

void W25Q_Write_Disable_STD(qspi* t)
{
	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x04);
    QSPI_SS_HIGH((int)t);
}

void W25Q_Wait_Busy_STD(qspi* t)   		//等待空闲
{
	volatile signed int time;
	while((W25Q_ReadSR_STD(t)&0x01)==0x01) // 等待BUSY位清空
	{
		time = 5000;
		while(time)
		{
			__asm("nop");
			time--;
		};
	}
}

////读取SPI FLASH
////在指定地址开始读取指定长度的数据
////pBuffer:数据存储区
////ReadAddr:开始读取的地址(24bit)
////NumByteToRead:要读取的字节数(最大65535)
//void W25Q_Read_STD(qspi* t,u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)
//{
// 	u16 i;
// 	QSPI_SS_LOW((int)t);                            		//使能器件
// 	QSPI_ReadWriteByte(t,0x03);         				//发送读取命令
//
//    QSPI_ReadWriteByte(t,(u8)((ReadAddr)>>16));  		//发送24bit地址
//    QSPI_ReadWriteByte(t,(u8)((ReadAddr)>>8));
//    QSPI_ReadWriteByte(t,(u8)ReadAddr);
//    for(i=0;i<NumByteToRead;i++)
//	{
//        pBuffer[i]=QSPI_ReadWriteByte(t,0XFF);   		//循环读数
//    }
//    QSPI_SS_HIGH((int)t);
//}

////SPI在一页(0~65535)内写入少于256个字节的数据
////在指定地址开始写入最大256字节的数据
////pBuffer:数据存储区
////WriteAddr:开始写入的地址(24bit)
////NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
//void W25Q_Write_Page_STD(qspi* t,u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
//{
// 	u16 i;
//    W25Q_Write_Enable_STD(t);                  					//SET WEL
//    QSPI_SS_LOW((int)t);                            						//使能器件
//
//    QSPI_ReadWriteByte(t,0x02);      									//发送写页命令
//
//    QSPI_ReadWriteByte(t,(uint8_t)((WriteAddr)>>16)); 				//发送24bit地址
//    QSPI_ReadWriteByte(t,(uint8_t)((WriteAddr)>> 8));
//    QSPI_ReadWriteByte(t,(uint8_t)((WriteAddr)>> 0));
//    for(i=0;i<NumByteToWrite;i++)QSPI_ReadWriteByte(t,pBuffer[i]);	//循环写数
//
//    QSPI_SS_HIGH((int)t);  													//取消片选
//	W25Q_Wait_Busy_STD(t);					   						//等待写入结束
//}

//void W25Q_Write_Page_Quad(qspi* t,u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)  //四线DMA写，自动片选和非自动片选都OK
//{
//	dma_tcd * d;
//	d =   (DMA_TCD_02) + (((int)t-0x60000000)>>28)*2;
//
// 	t->U32_SSIENR.SSIC_EN = 0;  //关闭
//
//	d->saddr = (UINT32)pBuffer;      //源地址
//	d->U32_Word1.smod = 0;
//	d->U32_Word1.ssize = 0;		 //源地址传输长度 8bit
//	d->U32_Word1.soff = 1;		 //源地址每次的偏移量
//	d->slastr = 0;
//
//	d->daddr = (UINT32)(&t->DR);		 //目的地址
//	d->U32_Word1.dmod = 0;
//	d->U32_Word1.dsize = 0;		 //目的地址传输长度 8bit
//	d->U32_Word5.doff = 0;		 //目的地址每次的偏移量
//	d->dlast_sgar = 0;
//
//	d->nbytes = 1;		 	 //小循环传输数目
//
//	d->U32_Word7.biter = NumByteToWrite;           //大循环次数
//	d->U32_Word5.citer = NumByteToWrite;		      //大循环次数
//
//	d->U32_Word5.citer_e_link = 0;
//	d->U32_Word7.biter_e_link = 0;
//
//	d->U32_Word7.d_req = 1;			  //硬件请求在结束时被禁用
//
//	d->U32_Word7.int_maj = 0;		 //大循环完成中断
//
//	DMA_CTL->U32_SERQR.SERQ = 2 + (((int)t-0x60000000)>>28)*2;        	 //开启QSPI0_TX_DMA_Channel 请求
//
//
//	QSPI_Standard_Init(t);  //切回单线
//	W25Q_Write_Enable_STD(t);                  					  //单线开启Flash写使能
//
//    QSPI_Quad_Init(t,CS);   //Quad Write Command 32H
//
// 	t->U32_SSIENR.SSIC_EN = 0;  //失能
//    t->U32_CTRLR1.NDF = NumByteToWrite-1;
// 	t->U32_CTRLR0.TMOD = 1;				//0：全双工，1：只发，2只读
//    t->U32_SPICTRLR0.WAIT_CYCLES = 0;   //等待周期数
//    t->U32_SPICTRLR0.TRANS_TYPE = 0;    //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//    t->U32_SPICTRLR0.ADDR_L = 6;		//地址长度0:No, 6:24bit, 8:32bit, 10:40bit
//
//    t->DMATDLR = 0;
//
//    t->U32_SSIENR.SSIC_EN = 1;  //使能
//
//#if CS
//    QSPI_SS_LOW((int)t);
//#endif
//    __asm("nop");__asm("nop");__asm("nop");
//    t->DR = 0x32;
//    t->DR = WriteAddr;
//
// 	t->U32_DMACR.TDMAE = 1;
//
// 	d->U32_Word7.done = 0;
//
// 	while(!d->U32_Word7.done)
// 	{
// 		__asm("nop");__asm("nop");__asm("nop");
// 	}
//
//
//#if CS
//    QSPI_SS_HIGH((int)t);
//#endif
//
//	QSPI_Standard_Init(t);  //切回单线
//	W25Q_Wait_Busy_STD(t);
//}
////无检验写SPI FLASH
////必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
////具有自动换页功能
////在指定地址开始写入指定长度的数据,但是要确保地址不越界!
////pBuffer:数据存储区
////WriteAddr:开始写入的地址(24bit)
////NumByteToWrite:要写入的字节数(最大65535)
////CHECK OK
//void W25QXX_Write_NoCheck(qspi* t,u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite,unsigned char type)
//{
//	u16 pageremain;
//	pageremain=256-WriteAddr%256; //单页剩余的字节数
//	if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
//	while(1)
//	{
//		if(type == 1)
//			W25Q_Write_Page_STD(t,pBuffer,WriteAddr,pageremain);
//		else if(type == 4)
//			W25Q_Write_Page_Quad(t,pBuffer,WriteAddr,pageremain);
//		if(NumByteToWrite==pageremain)break;//写入结束了
//	 	else //NumByteToWrite>pageremain
//		{
//			pBuffer+=pageremain;
//			WriteAddr+=pageremain;
//
//			NumByteToWrite-=pageremain;			  //减去已经写入了的字节数
//			if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
//			else pageremain=NumByteToWrite; 	  //不够256个字节了
//		}
//	}
//}
//
//void W25Q_BlockErase64KB_STD(qspi* t,u32 addr)
//{
//	addr*=(64*1024);
//	W25Q_Write_Enable_STD(t);                 	//SET WEL
//	W25Q_Wait_Busy_STD(t);
//	QSPI_SS_LOW((int)t);                           	  	//使能器件
//	QSPI_ReadWriteByte(t,0xD8);   			//发送片擦除命令
//
//	QSPI_ReadWriteByte(t,(uint8_t)((addr)>>16)); 			//发送24bit地址
//	QSPI_ReadWriteByte(t,(uint8_t)((addr)>>8));
//	QSPI_ReadWriteByte(t,(uint8_t)addr);
//	QSPI_SS_HIGH((int)t);                           	//取消片选
//	W25Q_Wait_Busy_STD(t);   				   	//等待芯片擦除结束
//}

void W25QXX_Open_QUAD(qspi* t)
{
	unsigned char temp1 = 0,temp2 = 0;

	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x05);
	temp1 = QSPI_ReadWriteByte(t,0xFF);
	QSPI_SS_HIGH((int)t);

	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x35);
	temp2 = QSPI_ReadWriteByte(t,0xFF);
	QSPI_SS_HIGH((int)t);
//LTPrintf("before %x\r\n",temp2);
	W25Q_Write_Enable_STD(t);

	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x31);
	QSPI_ReadWriteByte(t,temp2|0x02);
	QSPI_SS_HIGH((int)t);

	W25Q_Wait_Busy_STD(t);

	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x35);
	temp2 = QSPI_ReadWriteByte(t,0xFF);
	QSPI_SS_HIGH((int)t);

	if((temp2 & (1<<1)) != (1<<1))
	{
		QSPI_SS_LOW((int)t);
		QSPI_ReadWriteByte(t,0x01);
		QSPI_ReadWriteByte(t,temp1);
		QSPI_ReadWriteByte(t,temp2|(1<<1));
		QSPI_SS_HIGH((int)t);

		W25Q_Wait_Busy_STD(t);
	}
}


void W25QXX_Output_Driver_Strength(qspi* t)
{
	unsigned char temp = 0;

	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x15);
	temp = QSPI_ReadWriteByte(t,0xFF);
	QSPI_SS_HIGH((int)t);

	W25Q_Write_Enable_STD(t);

	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x11);
	temp = QSPI_ReadWriteByte(t,temp&0x9F);
	QSPI_SS_HIGH((int)t);

	W25Q_Wait_Busy_STD(t);

	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x15);
	temp = QSPI_ReadWriteByte(t,0xFF);
	QSPI_SS_HIGH((int)t);
}
//
////CRC : 0x707a0a43
//unsigned char data[256] =
//{
//	0x02, 0x04, 0x0B, 0xD5, 0x40, 0x42, 0x00, 0x28, 0x03, 0xDD, 0x0C, 0xF0, 0x17, 0xF9, 0x04, 0x60,
//	0xA0, 0x07, 0xBD, 0xE8, 0xF0, 0x87, 0x46, 0xF4, 0x80, 0x66, 0xE4, 0xE7, 0x00, 0x28, 0xF8, 0xDA,
//	0x0C, 0xF0, 0x0C, 0xF9, 0x04, 0x60, 0x6F, 0xF0, 0x00, 0x40, 0xF2, 0xE7, 0x70, 0xB5, 0x06, 0x46,
//	0x0C, 0xF0, 0x04, 0xF9, 0x04, 0x68, 0x05, 0x46, 0x0A, 0x22, 0x00, 0x21, 0x30, 0x46, 0xFF, 0xF7,
//	0xBD, 0xFF, 0x2C, 0x60, 0x70, 0xBD, 0x2D, 0xE9, 0xFE, 0x4F, 0x80, 0x46, 0x81, 0xEA, 0x03, 0x00,
//	0xC0, 0x0F, 0x0C, 0x46, 0x00, 0x90, 0x21, 0xF0, 0x00, 0x41, 0x23, 0xF0, 0x00, 0x45, 0xB8, 0xEB,
//	0x02, 0x00, 0xA9, 0x41, 0x05, 0xD2, 0x40, 0x46, 0x21, 0x46, 0x90, 0x46, 0x1C, 0x46, 0x0B, 0x46,
//	0x02, 0x46, 0x23, 0xF0, 0x00, 0x40, 0x10, 0x43, 0x47, 0xD0, 0x27, 0x0D, 0xC7, 0xF3, 0x0A, 0x00,
//	0xC3, 0xF3, 0x0A, 0x51, 0x02, 0x90, 0x40, 0x1A, 0x01, 0x90, 0x40, 0x28, 0x6B, 0xDA, 0xC3, 0xF3,
//	0x13, 0x00, 0x40, 0xF4, 0x80, 0x1B, 0x00, 0x98, 0x92, 0x46, 0x20, 0xB1, 0x00, 0x23, 0xD2, 0xEB,
//	0x03, 0x0A, 0x63, 0xEB, 0x0B, 0x0B, 0x01, 0x98, 0x59, 0x46, 0xC0, 0xF1, 0x40, 0x02, 0x50, 0x46,
//	0x00, 0xF0, 0x1F, 0xFA, 0x06, 0x46, 0x0D, 0x46, 0x50, 0x46, 0x59, 0x46, 0x01, 0x9A, 0x00, 0xF0,
//	0x37, 0xFA, 0x10, 0xEB, 0x08, 0x00, 0x61, 0x41, 0x00, 0x24, 0x87, 0xEA, 0x11, 0x52, 0x84, 0xEA,
//	0xE7, 0x73, 0x1A, 0x43, 0x40, 0xD0, 0x00, 0x9A, 0x62, 0xB3, 0x01, 0x9A, 0x01, 0x2A, 0x4F, 0xEA,
//	0x07, 0x52, 0x15, 0xDC, 0x00, 0x1B, 0x61, 0xEB, 0x02, 0x01, 0x4F, 0xF0, 0x00, 0x42, 0x02, 0xEA,
//	0x07, 0x52, 0xCD, 0xE9, 0x00, 0x42, 0x00, 0x1C, 0x41, 0xF5, 0x80, 0x11, 0x32, 0x46, 0x2B, 0x46
//};
//
//unsigned char Flash_buff_RX[512];
//unsigned char Flash_buff_TX[512];
//
char Test_QSPI_Port[6];
char QSPI_S[3][6]={"QSPI0","QSPI1","QSPI2"};

void QSPI_Port_Select(qspi* t)
{
	if(t == QSPI0)
	{
		memcpy(Test_QSPI_Port,QSPI_S[0],6);
	}
	else if(t == QSPI1)
	{
		memcpy(Test_QSPI_Port,QSPI_S[1],6);
	}
	else if(t == QSPI2)
	{
		memcpy(Test_QSPI_Port,QSPI_S[2],6);
	}
}
//
//void QSPI_STD_NoDMA_Test(qspi* t)
//{
//	UINT32 CRC1,CRC2;
//
//	QSPI_Port_Select(t);
//
//	Make_CRC32_Table();
//
//	QSPI_Standard_Init(t);
//
//	LTPrintf("%x \r\n",t->U32_TXFTLR.TFT);
//	LTPrintf("%x \r\n",t->U32_RXFTLR.RFT);
//
//	LTPrintf("%s_STD_NoDMA_Test \r\n",Test_QSPI_Port);
//
//	LTPrintf("ID:%x \r\n",W25Q_ReadID_STD(t));
//
//	W25Q_ReadID_STD(t);
//	W25Q_BlockErase64KB_STD(t,0);
//
//	W25QXX_Write_NoCheck(t,(unsigned char*)data,100,256,1);
//
//	W25Q_Read_STD(t,Flash_buff_RX,100,256);
//	CRC2 = GetCrc32(Flash_buff_RX,256,0);
//	CRC1 = GetCrc32((unsigned char*)data,256,0);
//
//	LTPrintf("CRC:%X \r\n",CRC2);
//	if(CRC1 != CRC2)
//	{
//		LTPrintf("%s STD Test Fail\r\n",Test_QSPI_Port);
//	}
//	else
//	{
//		LTPrintf("%s STD Test OK\r\n\r\n",Test_QSPI_Port);
//	}
//	while(1);
//}
//
//void QSPI_Dual_Init(qspi* t,unsigned char CS_type)
//{
//	t->XIPCR = 0;
//	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI0
//
//	t->U32_CTRLR0.SPI_FRF = 1;  //双线模式  0:标准 ，1双线，2四线
//	t->U32_CTRLR0.CFS = 0;		//
//	t->U32_CTRLR0.SSTE = 0;		//
//	t->U32_CTRLR0.SRL = 0;		//
//	t->U32_CTRLR0.SLV_OE = 0;	//
//
//	t->U32_CTRLR0.SCPOL = 0;	//闲置为高电平
//	t->U32_CTRLR0.SCPH = 0;		//数据抓取从一个时钟周期的第二个边沿开始
//	t->U32_CTRLR0.FRF = 0;		//摩托罗拉SPI模式
//	t->U32_CTRLR0.DFS = 0x07;   //数据格式为8bit
//
////	LTPrintf("CTRLR0:%x \r\n",t->U32_CTRLR0);
//
//	t->U32_CTRLR1.NDF = 0;		//传输数目
////	LTPrintf("NDF:%x \r\n",t->U32_CTRLR1.NDF);
//	t->U32_BAUDR.SCKDV = 300;  	//时钟频率
////	LTPrintf("SCKDV:%x \r\n",t->U32_BAUDR.SCKDV);
//
//	t->U32_TXFTLR.TXFTHR = 0;   //转移开始FIFO等级
////	LTPrintf("TXFTHR:%x \r\n",t->U32_TXFTLR.TXFTHR);
//	t->U32_TXFTLR.TFT = 0;		//传输FIFO阈值
////	LTPrintf("TFT:%x \r\n",t->U32_TXFTLR.TFT);
//
//	t->U32_RXFTLR.RFT = 7;		//接受FIFO阈值
////	LTPrintf("RFT:%x \r\n",t->U32_RXFTLR.RFT);
//
//	t->U32_TXFLR.TXTFL = 0;		//传输FIFO等级
////	LTPrintf("TXTFL:%x \r\n",t->U32_TXFLR.TXTFL);
//	t->U32_RXFLR.RXTFL = 0;  	//接受FIFO等级
////	LTPrintf("RXTFL:%x \r\n",t->U32_RXFLR.RXTFL);
//
//	t->U32_RXSDR.SE = 0;		//
//	t->U32_RXSDR.RSD = 0;		//接收数据采样延迟  根据时钟频率调整，时钟越快延迟采样延迟越低
//
//	t->U32_SPICTRLR0.CLK_STRETCH_EN = 1; //SPI时钟增强
//
//	t->U32_SPICTRLR0.INST_L = 0x02;		 //命令长度 0:No,1:4bit,2:8bit,3:16bit
//	t->U32_SPICTRLR0.TRANS_TYPE = 0;   //命令和地址的传输类型
////	LTPrintf("U32_SPICTRLR0:%x \r\n",t->U32_SPICTRLR0);
//
//	t->U32_SSIENR.SSIC_EN = 0;  //使能QSPI0
////	Delay_Ms(1000);
////	LTPrintf("SR:%x \r\n",t->U32_SR);
//
////------片选部分-------
//	if(CS_type == 1)
//	{
//		switch((UINT32)t)
//		{
//			case 0x60000000:
//				CCM->U32_QSPIGPIOCR.QSPI0_SS_GPIOPEN = 1; //片选软件控制
//				CCM->U32_QSPIGPIOCR.QSPI0_SS_PUE = 1;//片选上拉
//				CCM->U32_QSPIGPIOCR.QSPI0_SS_OBE = 1;//输出模式
//				break;
//
//			case 0x70000000:
//				CCM->U32_QSPIGPIOCR.QSPI1_SS_GPIOPEN = 1; //片选软件控制
//				CCM->U32_QSPIGPIOCR.QSPI1_SS_PUE = 1;//片选上拉
//				CCM->U32_QSPIGPIOCR.QSPI1_SS_OBE = 1;//输出模式
//
//				break;
//
//			case 0x80000000:
//				CCM->U32_QSPIGPIOCR.QSPI2_SS_GPIOPEN = 1; //片选软件控制
//				CCM->U32_QSPIGPIOCR.QSPI2_SS_PUE = 1;//片选上拉
//				CCM->U32_QSPIGPIOCR.QSPI2_SS_OBE = 1;//输出模式
//				break;
//
//			default:break;
//		}
//			QSPI_SS_HIGH((int)t);
//	}
//	else
//	{
//		switch((UINT32)t)
//		{
//			case 0x60000000:
//				CCM->U32_QSPIGPIOCR.QSPI0_SS_GPIOPEN = 0; // 硬件控制
//				break;
//			case 0x70000000:
//				CCM->U32_QSPIGPIOCR.QSPI1_SS_GPIOPEN = 0; // 硬件控制
//				break;
//			case 0x80000000:
//				CCM->U32_QSPIGPIOCR.QSPI2_SS_GPIOPEN = 0; // 硬件控制
//				break;
//		}
//	}
//}
//
//
//void QSPI_Dual_NoDMA_Test(qspi* t) //单线擦除，单线写入，双线读出，片选 非片选都OK
//{
//	int i = 0;
//	int num = 256;
//
//	UINT32 CRC1,CRC2;
//	Make_CRC32_Table();
//
//	QSPI_Port_Select(t);
//
//	LTPrintf("%s_Dual_NoDMA_Read_Test \r\n",Test_QSPI_Port);
//
////-------------------------------------------------------------------------------------------------------
//
//	QSPI_Standard_Init(t);  //单线初始化
//	LTPrintf("%x \r\n",W25Q_ReadID_STD(t)); //输出外挂Flash ID号 确认是否正确连接外挂Flash
////	W25QXX_Output_Driver_Strength(t);
//
//	W25Q_BlockErase64KB_STD(t,0);	//擦除第一个Block(64KByte)
//
//	W25QXX_Write_NoCheck(t,(unsigned char*)data,100,256,1);  //单线写数据，Flash没有双线写的指令
//
////====================================== 3BH ======================================
//	QSPI_Dual_Init(t,CS);   //Dual Read Command 3BH
//
//	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI0
//	t->U32_CTRLR0.TMOD = 2;		//0：全双工，1：只发，2只读
//	t->U32_CTRLR1.NDF = num-1;
//	t->U32_SPICTRLR0.WAIT_CYCLES = 0;  //等待周期数
//	t->U32_SPICTRLR0.ADDR_L = 8;//地址长度0:No, 6:24bit, 8:32bit
//
//	t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI0
//
//#if CS
// 	QSPI_SS_LOW((int)t);                            		//使能器件
//#endif
//
// 	t->DR = 0x3B;
// 	t->DR = ((u32)100)<<8;
// 	__asm("nop");__asm("nop");__asm("nop");
//
//	while(t->U32_SR.TFE == 0)	//等待TX FIFO空
//	{
//		__asm("nop");
//	}
//     for(i=0;i<num;i++)
//	{
//		while( t->U32_SR.RFNE == 0) 	//等RX FIFO非空，待接收完一个byte
//		{
//			__asm("nop");
//		}
//    	Flash_buff_RX[i]=t->DR;   		//循环读数
//    }
//
//#if CS
// 	QSPI_SS_HIGH((int)t);
//#endif
////====================================== 3BH ======================================
////	for(i = 0;i<num;i++)
////	{
////		LTPrintf("%x ",Flash_buff_RX[i]);
////	}
////	LTPrintf("\r\n");
//
//	CRC2 = GetCrc32(Flash_buff_RX,256,0);
//	CRC1 = GetCrc32(data,256,0);
//
//	LTPrintf("CRC1:%x \r\n",CRC1);
//	LTPrintf("CRC2:%x \r\n",CRC2);
//
//	if(CRC1 != CRC2)
//	{
//		LTPrintf("%s Dual Read Test Fail\r\n",Test_QSPI_Port);
//	}
//	else
//	{
//		LTPrintf("%s Dual Read Test OK\r\n",Test_QSPI_Port);
//	}
////-------------------------------------------------------------------------------------------------------
//
//}
//
//void QSPI_Dual_DMA_Test(qspi* t)    //片选 非片选都OK
//{
//	int num = 256;
//	int i = 0;
//	UINT32 CRC1,CRC2;
//	Make_CRC32_Table();
//
//	dma_tcd * d;
//	d =   (DMA_TCD_01) + (((int)t-0x60000000)>>28)*2;
//
//	memset(Flash_buff_RX,0,512);
//
//	QSPI_Port_Select(t);
//
////	LTPrintf("%s_Dual_DMA_Read_Test \r\n",Test_QSPI_Port);
////-------------------------------------------------------------------------------------------------------
//	QSPI_Standard_Init(t);  //QSPI0 单线初始化
////
////	LTPrintf("%x \r\n",W25Q_ReadID_STD(t)); //输出外挂Flash ID号 确认是否正确连接外挂Flash
////
//	W25Q_BlockErase64KB_STD(t,0);	//擦除第一个Block(64KByte)
//
//	for(i = 0;i<256;i++)
//		Flash_buff_TX[i] = i;
//	//首位两个数据不能是0，避免没有接收到数据也不知道
//	Flash_buff_TX[0] = 0xAA;
//	Flash_buff_TX[255] = 0x55;
//
//	W25QXX_Write_NoCheck(t,(unsigned char*)Flash_buff_TX,0,num,1);  //单线写数据，Flash没有双线写的指令
//
////=================================================================================
////====================================== 3BH ======================================
//	QSPI_Dual_Init(t,CS);   //Dual Read Command 3BH
//
//	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI0
//	t->U32_CTRLR0.TMOD = 2;		//0：全双工，1：只发，2只读
//	t->U32_CTRLR1.NDF = num-1;
//	t->U32_SPICTRLR0.WAIT_CYCLES = 8;	 //等待周期
//	t->U32_SPICTRLR0.ADDR_L = 6;	   //地址长度0:No, 6:24bit, 8:32bit
//	t->DMARDLR = 0;
//	t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI0
//
//	__asm("nop");__asm("nop");__asm("nop");
//
//
//	DMA_CTL->U32_SERQR.SERQ = 1 + (((int)t-0x60000000)>>28)*2;        	 //开启QSPI0_RX_DMA_Channel 请求
//
//	d->saddr = (UINT32)(&t->DR);      //源地址
//	d->U32_Word1.smod = 0;
//	d->U32_Word1.ssize = 0;		 //源地址传输长度 8bit
//	d->U32_Word1.soff = 0;		 //源地址每次的偏移量
//	d->slastr = 0;
//
//
//
//	d->daddr = (UINT32)Flash_buff_RX;		 //目的地址
//	d->U32_Word1.dmod = 0;
//	d->U32_Word1.dsize = 0;		 //目的地址传输长度 8bit
//	d->U32_Word5.doff = 1;		 //目的地址每次的偏移量
//	d->dlast_sgar = 0;
//
//	d->nbytes = 1;		 	 //小循环传输数目
//
//	d->U32_Word7.biter = 256;           //大循环次数
//	d->U32_Word5.citer = 256;		      //大循环次数
//
//	d->U32_Word5.citer_e_link = 0;
//	d->U32_Word7.biter_e_link = 0;
//
//	d->U32_Word7.d_req = 1;			 //硬件请求在结束时被禁用
//	d->U32_Word7.int_maj = 0;		 //大循环完成中断
// 	d->U32_Word7.start = 0;
// 	d->U32_Word7.bwc = 2;
//
//
//#if CS
//	QSPI_SS_LOW((int)t);                            		//使能器件
//#endif
//
//	t->DR = 0x3B;
//	t->DR = ((u32)0);
//
// 	t->U32_DMACR.RDMAE = 1;
//
//	d->U32_Word7.done = 0;
//
// 	while(!d->U32_Word7.done)
// 	{
// 		__asm("nop");__asm("nop");__asm("nop");
// 	}
//
//#if CS
//	QSPI_SS_HIGH((int)t);
//#endif
//
//	for(i = 0;i<num;i++)
//	{
//		LTPrintf("%x ",Flash_buff_RX[i]);
//	}
//	LTPrintf("\r\n");
//
//	CRC2 = GetCrc32(Flash_buff_RX,256,0);
//	CRC1 = GetCrc32(Flash_buff_TX,256,0);
//
//	if(CRC1 != CRC2)
//	{
//		LTPrintf("%s Dual DMA Test Fail\r\n",Test_QSPI_Port);
//	}
//	else
//	{
//		LTPrintf("%s Dual DMA Test OK\r\n",Test_QSPI_Port);
//	}
//
////====================================== 3BH ======================================
//}
//
//
void QSPI_Quad_Init(qspi* t,unsigned char CS_type)
{
	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI0

	t->U32_CTRLR0.SPI_FRF = 2;  //双线模式  0:标准 ，1双线，2四线
	t->U32_CTRLR0.CFS = 0;		//
	t->U32_CTRLR0.SSTE = 0;		//
	t->U32_CTRLR0.SRL = 0;		//
	t->U32_CTRLR0.SLV_OE = 0;	//

	t->U32_CTRLR0.SCPOL = 0;	//闲置为高电平
	t->U32_CTRLR0.SCPH = 0;		//数据抓取从一个时钟周期的第二个边沿开始
	t->U32_CTRLR0.FRF = 0;		//摩托罗拉SPI模式

//	LTPrintf("CTRLR0:%x \r\n",t->U32_CTRLR0);

	t->U32_CTRLR1.NDF = 0;		//传输数目
//	LTPrintf("NDF:%x \r\n",t->U32_CTRLR1.NDF);
	t->U32_BAUDR.SCKDV = 2;  	//时钟频率
//	LTPrintf("SCKDV:%x \r\n",t->U32_BAUDR.SCKDV);

	t->U32_TXFTLR.TXFTHR = 0;   //转移开始FIFO等级
//	LTPrintf("TXFTHR:%x \r\n",t->U32_TXFTLR.TXFTHR);
	t->U32_TXFTLR.TFT = 0;		//传输FIFO阈值
//	LTPrintf("TFT:%x \r\n",t->U32_TXFTLR.TFT);

	t->U32_RXFTLR.RFT = 3;		//接受FIFO阈值
//	LTPrintf("RFT:%x \r\n",t->U32_RXFTLR.RFT);

	t->U32_TXFLR.TXTFL = 0;		//传输FIFO等级
//	LTPrintf("TXTFL:%x \r\n",t->U32_TXFLR.TXTFL);
	t->U32_RXFLR.RXTFL = 0;  	//接受FIFO等级
//	LTPrintf("RXTFL:%x \r\n",t->U32_RXFLR.RXTFL);

	t->U32_RXSDR.SE = 0;		//
	t->U32_RXSDR.RSD = 0;		//接收数据采样延迟  根据时钟频率调整，时钟越快延迟采样延迟越低

	t->U32_SPICTRLR0.CLK_STRETCH_EN = 1; //SPI时钟增强

	t->U32_SPICTRLR0.INST_L = 0x02;		 //命令长度 0:No,1:4bit,2:8bit,3:16bit
//	LTPrintf("U32_SPICTRLR0:%x \r\n",t->U32_SPICTRLR0);

	t->U32_CTRLR0.TMOD = 2;		//0：全双工，1：只发，2只读
	t->U32_CTRLR0.DFS = 0x07;   //数据格式为8bit
	t->U32_SPICTRLR0.WAIT_CYCLES = 8;	 //等待周期
	t->U32_SPICTRLR0.ADDR_L = 6;	   //地址长度0:No, 6:24bit, 8:32bit
	t->U32_SPICTRLR0.TRANS_TYPE = 0;    //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
	t->DMARDLR = 0;

	t->U32_SSIENR.SSIC_EN = 0;  //使能QSPI0

//------片选部分-------
	if(CS_type == 1)
	{
		switch((UINT32)t)
		{
			case 0x60000000:
				CCM->U32_QSPIGPIOCR.QSPI0_SS_GPIOPEN = 1; //片选软件控制
				CCM->U32_QSPIGPIOCR.QSPI0_SS_PUE = 1;//片选上拉
				CCM->U32_QSPIGPIOCR.QSPI0_SS_OBE = 1;//输出模式
				break;

			case 0x70000000:
				CCM->U32_QSPIGPIOCR.QSPI1_SS_GPIOPEN = 1; //片选软件控制
				CCM->U32_QSPIGPIOCR.QSPI1_SS_PUE = 1;//片选上拉
				CCM->U32_QSPIGPIOCR.QSPI1_SS_OBE = 1;//输出模式

				break;

			case 0x80000000:
				CCM->U32_QSPIGPIOCR.QSPI2_SS_GPIOPEN = 1; //片选软件控制
				CCM->U32_QSPIGPIOCR.QSPI2_SS_PUE = 1;//片选上拉
				CCM->U32_QSPIGPIOCR.QSPI2_SS_OBE = 1;//输出模式
				break;

			default:break;
		}
			QSPI_SS_HIGH((int)t);
	}
	else
	{
		switch((UINT32)t)
		{
			case 0x60000000:
				CCM->U32_QSPIGPIOCR.QSPI0_SS_GPIOPEN = 0; // 硬件控制
				break;
			case 0x70000000:
				CCM->U32_QSPIGPIOCR.QSPI1_SS_GPIOPEN = 0; // 硬件控制
				break;
			case 0x80000000:
				CCM->U32_QSPIGPIOCR.QSPI2_SS_GPIOPEN = 0; // 硬件控制
				break;
		}
	}
}
//
//void QSPI_Quad_NoDMA_Test(qspi* t) //单线擦除，四线写入，四线读出  片选，非片选，6BH，EBH都OK
//{
//	int i = 0;
//	int num = 256;
//	UINT32 CRC1,CRC2;
//
//	Make_CRC32_Table();
//	QSPI_Port_Select(t);
//
//	LTPrintf("%s_Quad_NoDMA_Test \r\n",Test_QSPI_Port);
////-------------------------------------------------------------------------------------------------------
//
//#if 1
//	QSPI_Standard_Init(t);  //QSPI0 单线初始化
//
//	LTPrintf("%x \r\n",W25Q_ReadID_STD(t)); //输出外挂Flash ID号 确认是否正确连接外挂Flash
//	W25QXX_Open_QUAD(t);
//	W25QXX_Output_Driver_Strength(t);
//
//	W25Q_BlockErase64KB_STD(t,0);	//擦除第一个Block(64KByte)
//
//	W25QXX_Write_NoCheck(t,(unsigned char*)data,100,256,1);  //四线写数据
//#endif
//
//#if 1
//	W25Q_Read_STD(t,Flash_buff_RX,100,256);
////	for(i = 0;i<256;i++)
////		LTPrintf("%x ",Flash_buff_RX[i]);
//
//	CRC2 = GetCrc32(Flash_buff_RX,256,0);
//	LTPrintf("CRC:%x\r\n",CRC2);
//	if(CRC2 == 0x707a0a43)
//		LTPrintf("写入OK\r\n");
//	else
//		LTPrintf("写入失败\r\n");
//
//#endif
//
//#if 1
////====================================== 6BH ======================================
//	QSPI_Quad_Init(t,CS);   //Quad Read Command 6BH
//
// 	t->U32_SSIENR.SSIC_EN = 0;  		//失能QSPI
// 	t->U32_CTRLR0.TMOD = 2;				//0：全双工，1：只发，2只读
//    t->U32_CTRLR1.NDF = num-1;
//    t->U32_SPICTRLR0.ADDR_L = 6;	   //地址长度0:No, 6:24bit, 8:32bit
//    t->U32_SPICTRLR0.WAIT_CYCLES = 8;  //等待周期数
//    t->U32_SPICTRLR0.TRANS_TYPE = 0;   //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//    t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI
//
//#if CS
// 	QSPI_SS_LOW((int)t);                            		//使能器件
//#endif
//
//    t->DR = 0x6B;
//    t->DR = (100);
//    __asm("nop");__asm("nop");__asm("nop");
//
//	while(t->U32_SR.TFE == 0)	//等待TX FIFO空
//	{
//		__asm("nop");
//	}
//
//     for(i=0;i<num;i++)
//	{
//		while( t->U32_SR.RFNE == 0) 	//等RX FIFO非空，待接收完一个byte
//		{
//			__asm("nop");
//		}
//    	Flash_buff_RX[i]=t->DR;   		//循环读数
////    	Delay_Ms(500);
//    }
//
//#if CS
// 	QSPI_SS_HIGH((int)t);
//#endif
//
//	CRC1 = GetCrc32((unsigned char*)data,256,0);
//	CRC2 = GetCrc32(Flash_buff_RX,256,0);
//
//	LTPrintf("CRC1:%x \r\n",CRC1);
//	LTPrintf("CRC2:%x \r\n",CRC2);
//
//	if(CRC1 != CRC2)
//	{
//		LTPrintf("%s_Quad_NoDMA_Test 6BH Fail\r\n",Test_QSPI_Port);
//	}
//	else
//	{
//		LTPrintf("%s_Quad_NoDMA_Test 6BH OK\r\n",Test_QSPI_Port);
//	}
////====================================== 6BH ======================================
//
//#else
////====================================== EBH ======================================
//	u8 m = 0;
//	QSPI_Quad_Init(t,CS);   //Quad Read Command 6BH
//
//	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI
//	t->U32_CTRLR0.TMOD = 2;		//0：全双工，1：只发，2只读
//	t->U32_CTRLR1.NDF = num-1;		   //传输
//	t->U32_SPICTRLR0.ADDR_L = 8;	   //地址长度0:No, 6:24bit, 8:32bit
//	t->U32_SPICTRLR0.WAIT_CYCLES = 4;  //等待周期数
//	t->U32_SPICTRLR0.TRANS_TYPE = 1;   //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//	t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI
//
//#if CS
//	QSPI_SS_LOW((int)t);                            		//使能器件
//#endif
///***************************************************************************************
//
//注意：发送EB指令和后续24bit地址之后，下一个byte(0x20)确定是否使用Continuous Read Mode
//此模式可以让在发送一次EBH 后下一次读时不必再发送EBH。
//
//****************************************************************************************/
//	m = 0x00; //0x20: Continuous Read Mode
//	t->DR = 0xEB;
//	t->DR = (((u32)100)<<8) | m;
//	__asm("nop");__asm("nop");__asm("nop");
//
//	while(t->U32_SR.TFE == 0)	//等待TX FIFO空
//	{
//		__asm("nop");
//	}
//
//	 for(i=0;i<num;i++)
//	{
//		while( t->U32_SR.RFNE == 0) 	//等RX FIFO非空，待接收完一个byte
//		{
//			__asm("nop");
//		}
//		Flash_buff_RX[i]=t->DR;   		//循环读数
//	}
//#if CS
//	QSPI_SS_HIGH((int)t);
//#endif
//
//#if 0     //用于验证是否使用了连续读后，不需要再发0xEB。
//	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI
//	t->U32_SPICTRLR0.INST_L = 0;
//	t->U32_CTRLR1.NDF = num-1;		   //传输
//	t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI
//
//	#if CS
//		QSPI_SS_LOW((int)t);                            		//使能器件
//	#endif
//
//			t->DR = (((u32)100)<<8) | m;
//			__asm("nop");__asm("nop");__asm("nop");
//
//			while(t->U32_SR.TFE == 0)	//等待TX FIFO空
//			{
//				__asm("nop");
//			}
//
//			 for(i=0;i<num;i++)
//			{
//				while( t->U32_SR.RFNE == 0) 	//等RX FIFO非空，待接收完一个byte
//				{
//					__asm("nop");
//				}
//				Flash_buff_RX[i]=t->DR;   		//循环读数
//			}
//
//	#if CS
//		QSPI_SS_HIGH((int)t);
//	#endif
//#endif
//if(m == 0x20)				//Exit Continuous Read Mode
//{
//	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI0
//	t->U32_CTRLR1.NDF = 0;		   	   //传输
//	t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI0
//
//	#if CS
//		QSPI_SS_LOW((int)t);
//	#endif
//		t->DR = 0xEB;
//		t->DR = 0;
//		__asm("nop");__asm("nop");__asm("nop");
//
//		while(t->U32_SR.TFE == 0)	//等待TX FIFO空
//		{
//			__asm("nop");
//		}
//
//		while(t->U32_SR.BUSY) //等待QSPI空闲
//			__asm("nop");
//
//	#if CS
//		QSPI_SS_HIGH((int)t);
//	#endif
//}
//	CRC1 = GetCrc32((unsigned char*)data,256,0);
//	CRC2 = GetCrc32(Flash_buff_RX,256,0);
//
//	LTPrintf("CRC1:%x \r\n",CRC1);
//	LTPrintf("CRC2:%x \r\n",CRC2);
//
//	if(CRC1 != CRC2)
//	{
//		LTPrintf("%s_Quad_NoDMA_Test EBH Fail\r\n",Test_QSPI_Port);
//	}
//	else
//	{
//		LTPrintf("%s_Quad_NoDMA_Test EBH OK\r\n",Test_QSPI_Port);
//	}
////====================================== EBH ======================================
//
//#endif
//
//
////	for(i = 0;i<num;i++)
////	{
////		LTPrintf("%x ",Flash_buff_RX[i]);
////	}
////	LTPrintf("\r\n");
////
////-------------------------------------------------------------------------------------------------------
//
//}

#include "lt168_dma.h"
//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25Q_Read_STD(qspi* t,u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)
{
 	u16 i;
 	QSPI_SS_LOW((int)t);                            		//使能器件
 	QSPI_ReadWriteByte(t,0x03);         				//发送读取命令

    QSPI_ReadWriteByte(t,(u8)((ReadAddr)>>16));  		//发送24bit地址
    QSPI_ReadWriteByte(t,(u8)((ReadAddr)>>8));
    QSPI_ReadWriteByte(t,(u8)ReadAddr);
    for(i=0;i<NumByteToRead;i++)
	{
        pBuffer[i]=QSPI_ReadWriteByte(t,0XFF);   		//循环读数
    }
    QSPI_SS_HIGH((int)t);
}

u8 rx_test_buf[256]={0};
void QSPI_Quad_DMA2RGB(qspi* t,u32 flash_addr,u32 data_sum)     //片选和非片选都OK
{
	u32 i = 0;
	u32 len = 65280,cnt = 4;
//	int num = 256;

//	dma_tcd * d;
//	d =   (DMA_TCD_01) + (((int)t-0x60000000)>>28)*2;
//	CCM->U32_QSPIGPIOCR.QSPI1_SS_GPIOPEN = 1; //片选软件控制
//	CCM->U32_QSPIGPIOCR.QSPI1_SS_PUE = 1;//片选上拉
//	CCM->U32_QSPIGPIOCR.QSPI1_SS_OBE = 1;//输出模式
//	QSPI_Port_Select(t);

//	CCM->U32_QSPIXIPMCFR.QSPI1_XIPEN = 0;
//	CCM->U32_QSPIXIPMCFR.QSPI1_DATA_ENCR_EN = 0;
//	W25QXX_Exit_QPI(t);

	QSPI_Standard_Init(t);  //QSPI0 单线初始化
//	LTPrintf("%s_Quad_DMA_Test \r\n",Test_QSPI_Port);
//	LTPrintf("%x \r\n",W25Q_ReadID_STD(t)); //输出外挂Flash ID号 确认是否正确连接外挂Flash

//	W25Q_Read_STD(t,rx_test_buf,flash_addr,256);
//	for(i=0;i<256;i++)
//	{
//		if(i%16==0)	LTPrintf("\r\n");
//		LTPrintf("%x ",rx_test_buf[i]);
//	}

	W25QXX_Open_QUAD(t);
//	W25QXX_Output_Driver_Strength(t);    //Flash 输出能力

//====================================== 6BH ======================================

//======================================= DMA ======================================

	dma_tcd *test_ch;
	dma_control_config_ts dma_control_config;
	dma_tcd_config_ts dma_tcd_config;

	/* DMA 控制部分，使用默认配置 */
	DMA_Control_Reset(&dma_control_config);
	DMA_Control_Init(&dma_control_config);


	/* TCD 部分 */
	DMA_TCD_Reset(&dma_tcd_config);  //更改新配置之前必须清空该结构体

	/* DMA Channel */
	test_ch = DMA_TCD_03;

//	/* Interrupt  */
//	NULL;
//	dma_tcd_config.minor_link = Enable;
//	dma_tcd_config.minor_link_channel = test_ch - DMA_TCD_00;  //Channel num (0-15)

//	dma_tcd_config.bwc = DMA_EngineStalls_4cycles;


	for(i=0;i<cnt;i++)
	{
		//Minor Loop---------------------------------------------------------------
	//	d->saddr = (UINT32)(&t->DR);      //源地址
	//	d->U32_Word1.smod = 0;
	//	d->U32_Word1.ssize = 0;		 //源地址传输长度 8bit
	//	d->U32_Word1.soff = 0;
	//	d->slastr = 0;

		/* Source part---Start */
		dma_tcd_config.source = (UINT32)(&t->DR);		     // 源地址
		dma_tcd_config.source_modulo = DMA_MOD_Disable;		 // 设0则禁用，设 0<n<=31,则源地址低N位可以变，一般禁用比较鸡肋，无实际应用场合
		dma_tcd_config.source_datasize = DMA_DataSize_8bit;  // 源地址传输长度  0:8bit, 1:16bit, 2:32bit
		dma_tcd_config.source_offset = 0;					 // 每次向总线读取数据后源地址的偏移量 (带符号能向上、向下、不变)
		dma_tcd_config.source_last_address_adjustment = 0;	 // 大循环计数结束后，源地址写回到TCD的偏移量 (带符号能向上、向下、不变)
		/* Source part---End */

	//	d->daddr = (UINT32)Flash_buff_RX;		 //目的地址
	//	d->U32_Word1.dmod = 0;
	//	d->U32_Word1.dsize = 0;		 //目的地址传输长度 8bit
	//	d->U32_Word5.doff = 1;       //目的地址每次的偏移量
	//	d->dlast_sgar = 0;

		/* Destination part---Start */
		dma_tcd_config.destin = RAM_display_addr+(len*i);		     // 目的地址
		dma_tcd_config.destin_modulo = DMA_MOD_Disable;		 // 设0则禁用，设 0<n<=31,则目的地址低N位可以变，一般禁用比较鸡肋，无实际应用场合
		dma_tcd_config.destin_datasize = DMA_DataSize_8bit; // 目的地址传输长度 0:8bit, 1:16bit, 2:32bit
		dma_tcd_config.destin_offset = 1;					 // 每次向总线写入数据后目的地址的偏移量 (带符号能向上、向下、不变)
		dma_tcd_config.destin_last_address_adjustment = 0;	 // 大循环计数结束后，目的地址写回到TCD的偏移量 (带符号能向上、向下、不变)
		/* Destination part---End */

	//	d->nbytes = 1; 			 //传输数目
	//	//Major Loop---------------------------------------------------------------
	//	d->U32_Word7.biter = num;           //大循环次数
	//	d->U32_Word5.citer = num;		    //小循环次数
	//
	//	d->U32_Word5.citer_e_link = 0;
	//	d->U32_Word7.biter_e_link = 0;
	//
	//	d->U32_Word7.d_req = 1;
	//	d->U32_Word7.int_maj = 0;
	// 	d->U32_Word7.start = 0;
	// 	d->U32_Word7.bwc = 2;

//		dma_tcd_config.minor_transfer_num = len; /* 小循环传输数目 */
//
//		/* Major Loop--- */
//		dma_tcd_config.major_loop_num = 1;  /* 小循环次数 */
		dma_tcd_config.minor_transfer_num = 1; /* 小循环传输数目 */

		/* Major Loop--- */
		dma_tcd_config.major_loop_num = len;  /* 小循环次数 */
		dma_tcd_config.d_req = 1;

	// 	DMA_CTL->U32_SERQR.SERQ = 1 + (((int)t-0x60000000)>>28)*2;        	 //开启QSPI_RX_DMA_Channel 请求
	//======================================= DMA ======================================
	 	DMA_Channel_Hardware_Request_Enable(test_ch);
		DMA_TCD_Init(test_ch,&dma_tcd_config);

		/* 开启通道的错误中断，判断配置是否出错 */
		EIC->IER |= 1<<5;
		DMA_Channel_Error_Interrupt_Enable(test_ch);

	 	QSPI_Quad_Init(t,CS);   //Quad Read Command 6BH

	 	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI
		t->U32_CTRLR0.TMOD = 2;		//0：全双工，1：只发，2只读
		t->U32_CTRLR1.NDF = len-1;
		t->U32_SPICTRLR0.WAIT_CYCLES = 8;	 //等待周期
		t->U32_SPICTRLR0.ADDR_L = 6;	   //地址长度0:No, 6:24bit, 8:32bit
		t->U32_SPICTRLR0.TRANS_TYPE = 0;    //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
		t->DMARDLR = 0;
	    t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI

		__asm("nop");__asm("nop");__asm("nop");

	#if CS
	 	QSPI_SS_LOW((int)t);             //使能器件               		//使能器件
	#endif

		t->DR = 0x6B;
		t->DR = flash_addr+(len*i);

	 	t->U32_DMACR.RDMAE = 1;

	// 	d->U32_Word7.done = 0;
	//
	// 	while(!d->U32_Word7.done)
	// 	{
	// 		__asm("nop");__asm("nop");__asm("nop");
	// 	}

		/* 手动清除通道的done位 */
		DMA_Channel_Clear_Done(test_ch);

		/* 软件启动 software start */
	//	DMA_Channel_Start(test_ch);

		while (DMA_Channel_Check_Donebit(test_ch) == 0) /* 直接等待大循环完成 */
		{
			asm("nop");
		}
		t->U32_DMACR.RDMAE = 0;

	#if CS
	 	QSPI_SS_HIGH((int)t);
	#endif
	}
//	LTPrintf("\r\nRGB");
//	for(i=0;i<256;i++)
//	{
//		if(i%16==0)	LTPrintf("\r\n");
//		LTPrintf("%x ",IO_READ8(0x840000+i));
//	}

}

void LT168_Display_Picture(u16 x,u16 y,u16 w,u16 h,u32 flash_addr)     //片选和非片选都OK
{
	u32 i = 0;
	u32 len = w*2,cnt = h;

	qspi* t = QSPI1;
	dma_tcd *test_ch = DMA_QSPI1_RX_Channel;

	dma_control_config_ts dma_control_config;
	dma_tcd_config_ts dma_tcd_config;

	/* DMA 控制部分，使用默认配置 */
	DMA_Control_Reset(&dma_control_config);
	DMA_Control_Init(&dma_control_config);

	/* TCD 部分 */
	DMA_TCD_Reset(&dma_tcd_config);  //更改新配置之前必须清空该结构体

	/* DMA Channel */

	/* Source part---Start */
	dma_tcd_config.source = (UINT32)(&t->DR);		     // 源地址
	dma_tcd_config.source_modulo = DMA_MOD_Disable;		 // 设0则禁用，设 0<n<=31,则源地址低N位可以变，一般禁用比较鸡肋，无实际应用场合
	dma_tcd_config.source_datasize = DMA_DataSize_8bit;  // 源地址传输长度  0:8bit, 1:16bit, 2:32bit
	dma_tcd_config.source_offset = 0;					 // 每次向总线读取数据后源地址的偏移量 (带符号能向上、向下、不变)
	dma_tcd_config.source_last_address_adjustment = 0;	 // 大循环计数结束后，源地址写回到TCD的偏移量 (带符号能向上、向下、不变)
	/* Source part---End */

	/* Destination part---Start */
	dma_tcd_config.destin = RAM_display_addr + 2*LCD_XSIZE_TFT*y + 2*x;		     // 目的地址
	dma_tcd_config.destin_modulo = DMA_MOD_Disable;		 // 设0则禁用，设 0<n<=31,则目的地址低N位可以变，一般禁用比较鸡肋，无实际应用场合
	dma_tcd_config.destin_datasize = DMA_DataSize_8bit; // 目的地址传输长度 0:8bit, 1:16bit, 2:32bit
	dma_tcd_config.destin_offset = 1;					 // 每次向总线写入数据后目的地址的偏移量 (带符号能向上、向下、不变)
	dma_tcd_config.destin_last_address_adjustment = (LCD_XSIZE_TFT-w)*2;	 // 大循环计数结束后，目的地址写回到TCD的偏移量 (带符号能向上、向下、不变)
	/* Destination part---End */

//	dma_tcd_config.minor_transfer_num = len; /* 小循环传输数目 */
//	/* Major Loop--- */
//	dma_tcd_config.major_loop_num = 1;  /* 小循环次数 */
//	dma_tcd_config.d_req = 1;
	dma_tcd_config.minor_transfer_num = 1; /* 小循环传输数目 */
	/* Major Loop--- */
	dma_tcd_config.major_loop_num = len;  /* 小循环次数 */
	dma_tcd_config.d_req = 1;
//======================================= DMA ======================================
	DMA_TCD_Init(test_ch,&dma_tcd_config);

	/* 开启通道的错误中断，判断配置是否出错 */
	EIC->IER |= 1<<5;
	DMA_Channel_Error_Interrupt_Enable(test_ch);

	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI
	t->U32_CTRLR1.NDF = len-1;
	t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI

//	__asm("nop");__asm("nop");__asm("nop");

	for(i=0;i<cnt;i++)
	{
		DMA_Channel_Hardware_Request_Enable(test_ch);
		DMA_Channel_Clear_Done(test_ch);

		t->U32_DMACR.RDMAE = 1;

	#if CS
	 	QSPI_SS_LOW((int)t);             //使能器件               		//使能器件
	#endif

		t->DR = 0x6B;
		t->DR = flash_addr+(len*i);



//		/* 手动清除通道的done位 */

		/* 软件启动 software start */
	//	DMA_Channel_Start(test_ch);

		while (DMA_Channel_Check_Donebit(test_ch) == 0) /* 直接等待大循环完成 */
		{
			asm("nop");
		}
		t->U32_DMACR.RDMAE = 0;

	#if CS
	 	QSPI_SS_HIGH((int)t);
	#endif
	}
}

//---------------------------------------------------------- XIP ----------------------


void W25QXX_Enter_QPI_STD(qspi* t)
{
	QSPI_SS_LOW((int)t);
	QSPI_ReadWriteByte(t,0x38);
	QSPI_SS_HIGH((int)t);
}

//void QSPI_XIP_Test(void)
//{
//	int j;
//
//	QSPI_Standard_Init(QSPI0);
//
////	LTPrintf("%x \r\n",W25Q_ReadID_STD(QSPI0));
//	W25QXX_Open_QUAD(QSPI0);
//	W25QXX_Output_Driver_Strength(QSPI0);    //Flash 输出能力
//	W25QXX_Enter_QPI_STD(QSPI0);
//
//
////---------------- 配置 Read Parameters ------------------
//	QSPI0->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//	QSPI0->CTRLR1 = 0x00;			  //NDF = 0;
//
//	QSPI0->CTRLR0 = 0x00800407;// QUAD 只写 数据8bit
//	QSPI0->SPICTRLR0 = 0x40000202|(6<<11);
//	QSPI0->BAUDR = 4;
//	QSPI0->U32_SSIENR.SSIC_EN = 1;
//
//	QSPI_SS_LOW((int)QSPI0);
//	QSPI0->DR = 0xC0;			//Set Read Parameters
//	QSPI0->DR = 0x21;			//6 dummy clocks,16 byte wrap length
//	__asm("nop");__asm("nop");__asm("nop");
//
//	while(QSPI0->U32_SR.TFE == 0){__asm("nop");}
//	while(QSPI0->U32_SR.BUSY == 1){__asm("nop");}
//	QSPI_SS_HIGH((int)QSPI0);
//
//
//
//
////---------------- 配置 Read Parameters ------------------
//
//	QSPI0->U32_SSIENR.SSIC_EN = 0;
//
////	QSPI0->U32_XIPCR.FRF = 1;   //双线模式
////	QSPI0->U32_XIPCR.INST_L = 2;//8bit 指令长度
////	QSPI0->U32_XIPCR.ADDR_L = 6;//24 bit Address length
////	QSPI0->U32_XIPCR.TRANS_TYPE = 0;//命令和地址通过单线模式输出
////	QSPI0->U32_XIPCR.XIP_MBL = 3;//Mode bits length equal to 16
//	QSPI0->XIPCR = 0x28c0046a|(2<<13);
//
//	QSPI0->U32_XIPIIR.INCR_INST = 0xEB;   //Flash 读取指令
//	QSPI0->XIPMBR = 0;
//	QSPI0->XIPWIR = 0x0C;
//
//	QSPI0->CTRLR0 = 0x0080001f;
//	QSPI0->SPICTRLR0 = 0x6830021a|(2<<11);
//	QSPI0->BAUDR = 4;
//
//	QSPI0->U32_SSIENR.SSIC_EN = 1;
////	Delay_Ms(5);
//
//	CCM->U32_QSPIGPIOCR.QSPI0_SS_GPIOPEN = 0; // 硬件控制
////	CCM->U32_QSPIXIPMCFR.QSPI0_ARRANGE_DATA_ON = 1;
//
//	//XIP Enable
//	CCM->U32_QSPIXIPMCFR.QSPI0_XIPEN = 1;
//
////	QSPI_SS_LOW((int)QSPI0);
//	for(j=0; j<256; j++)
//	{
////	   LTPrintf("%x ", *(unsigned char *)(0x60000064+j));
//	   Flash_buff_RX[j] = *(unsigned char *)(0x60000000+j);
//	}
////	QSPI_SS_HIGH((int)QSPI0);
//
////	Delay_Ms(50);
//	CCM->U32_QSPIXIPMCFR.QSPI0_XIPEN = 0;
//
////QSPI0 配置为 QPI只写
//	QSPI0->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//	QSPI0->CTRLR1 = 0x00;			  //NDF = 0;
//
//	QSPI0->CTRLR0 = 0x00800407;// QUAD 只写 数据8bit
//	QSPI0->SPICTRLR0 = 0x40000202|(6<<11);
//	QSPI0->BAUDR = 4;
//	QSPI0->U32_SSIENR.SSIC_EN = 1;
//
//	QSPI_SS_LOW((int)QSPI0);
//	QSPI0->DR = 0xFF;				//Exit QPI mode
//	__asm("nop");__asm("nop");__asm("nop");
//
//	while(QSPI0->U32_SR.TFE == 0){__asm("nop");}
//	while(QSPI0->U32_SR.BUSY == 1){__asm("nop");}
//	QSPI_SS_HIGH((int)QSPI0);
//}

//void QSPI_XIP_Test(qspi* t,unsigned char flag)
//{
//	int i;
//	unsigned long CRC32;
//	uint32_t start_addr = 0;
//	UINT32 addr = 0;
//
//	addr = (UINT32)t;
//
//	//----------------------- Flash 退出QPI -----------------------
//	//QSPI0 配置为 QPI只写
//		t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//		t->CTRLR1 = 0x00;			  //NDF = 0;
//		t->CTRLR0 = 0x00800407;// QUAD 只写 数据8bit
//		t->SPICTRLR0 = 0x40000202|(6<<11);
//		t->BAUDR = 8;
//		t->U32_SSIENR.SSIC_EN = 1;
//
//		t->DR = 0xFF;				//Exit QPI mode
//		__asm("nop");__asm("nop");__asm("nop");
//
//		while(t->U32_SR.TFE == 0){__asm("nop");}
//		while(t->U32_SR.BUSY == 1){__asm("nop");}
//		//----------------------- Flash 退出QPI -----------------------
//
//
//
//	QSPI_Standard_Init(t);  //QSPI单线初始化
//
////	LTPrintf("%x \r\n",W25Q_ReadID_STD(t)); //输出外挂Flash ID号 确认是否正确连接外挂Flash
//	W25QXX_Open_QUAD(t);
//	W25QXX_Output_Driver_Strength(t);
//#if 0
////-------------------------提前先flash写入部分数据---------
//
////	W25QXX_Output_Driver_Strength(t);
//
//	W25Q_BlockErase64KB_STD(t,0);	//擦除第一个Block(64KByte)
//
//	W25QXX_Write_NoCheck(t,(unsigned char*)data,100,256,4);  //四线写数据
//
//	W25Q_Read_STD(t,Flash_buff_RX,100,256);
//	Make_CRC32_Table();
//	CRC32 = GetCrc32(Flash_buff_RX,256,0);
//	LTPrintf("CRC:%x\r\n",CRC32);
//
////-------------------------提前先flash写入部分数据---------
//#endif
//
//	W25QXX_Enter_QPI_STD(t);   //Flash 进入QPI模式
//
////---------------- 配置 Read Parameters ------------------
//
//	t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//	t->CTRLR1 = 0x00;			  //NDF = 0;
//
//	t->U32_CTRLR0.SPI_FRF = 0x02;  //0:STD, 1:Dual,2:Quad
//	t->U32_CTRLR0.CFS = 0x00;	   //Microwire frame format. 此模式不用，不管
//	t->U32_CTRLR0.SSTE = 0x00;	   //不管
//	t->U32_CTRLR0.SRL = 0x00;	   //不管
//	t->U32_CTRLR0.SLV_OE = 0x00;   //不管
//	t->U32_CTRLR0.TMOD = 0x01;	   //0：全双工，1：只发，2只读
//	t->U32_CTRLR0.SCPOL = 0x00;	   //SPI00
//	t->U32_CTRLR0.SCPH = 0x00;	   //SPI00
//	t->U32_CTRLR0.FRF = 0x00;	   //0:Motorola SPI
//	t->U32_CTRLR0.DFS = 0x07;	   //7: 8bit数据传输
//
//	t->BAUDR = 4;				   //测试先用4分频
//
//	t->U32_SPICTRLR0.ADDR_L = 0;		   //0:没有地址,6: 24bit 地址 ,8:32bit 地址
//	t->U32_SPICTRLR0.CLK_STRETCH_EN = 1;   //时钟增强
//	t->U32_SPICTRLR0.INST_L = 0x02;		   //0:没有指令,1: 4bit指令,2: 8bit指令,3:16bit指令
//	t->U32_SPICTRLR0.TRANS_TYPE = 0x02;	   //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//	t->U32_SPICTRLR0.WAIT_CYCLES = 8;     //地址和数据之间Dummy时钟数
//
//	t->U32_SSIENR.SSIC_EN = 1;
//
//
//#if !CS
//	*(volatile unsigned char*)(0x40010000+0x23) &= ~(1<<((((int)t - 0x60000000)>>28)+5));//硬件控制
//#else
//	*(volatile unsigned char*)(0x40010000+0x23) |= (1<<((((int)t - 0x60000000)>>28)+5)); //软件控制
//#endif
//
//
//#if CS
//	QSPI_SS_LOW((int)t);
//#endif
//
//	t->DR = 0xC0;			//Set Read Parameters
//	t->DR = 0x31;			//8 dummy clocks,8 byte wrap length
//	__asm("nop");__asm("nop");__asm("nop");
//
//	while(t->U32_SR.TFE == 0) {__asm("nop");}
//	while(t->U32_SR.BUSY == 1){__asm("nop");}
//
//#if CS
//	QSPI_SS_HIGH((int)t);
//#endif
//
////---------------- 配置 Read Parameters ------------------
//
////----------------------- 配置 XIP -----------------------
//
//	t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//
//	t->U32_CTRLR0.SPI_FRF = 0x02;  //0:STD, 1:Dual,2:Quad
//	t->U32_CTRLR0.CFS = 0x00;	   //Microwire frame format. 此模式不用，不管
//	t->U32_CTRLR0.SSTE = 0x00;	   //不管
//	t->U32_CTRLR0.SRL = 0x00;	   //不管
//	t->U32_CTRLR0.SLV_OE = 0x00;   //不管
//	t->U32_CTRLR0.TMOD = 0x02;	   //0：全双工，1：只发，2只读
//	t->U32_CTRLR0.SCPOL = 0x00;	   //SPI00
//	t->U32_CTRLR0.SCPH = 0x00;	   //SPI00
//	t->U32_CTRLR0.FRF = 0x00;	   //0:Motorola SPI
//	t->U32_CTRLR0.DFS = 0x1F;	   //7: 8bit数据传输,0x1F: 32bit
//
//	t->U32_RXFTLR.RFT = 0;
//
//	t->BAUDR = 4;				   //FPGA只能用4分频,
//
////	t->U32_SPICTRLR0.ADDR_L = 0x06;		   //0:没有地址,6: 24bit 地址 ,8:32bit 地址
////	t->U32_SPICTRLR0.CLK_STRETCH_EN = 1;   //时钟增强
////	t->U32_SPICTRLR0.INST_L = 0x02;		   //0:没有指令,1: 4bit指令,2: 8bit指令,3:16bit指令
////	t->U32_SPICTRLR0.TRANS_TYPE = 0x02;	   //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
////	t->U32_SPICTRLR0.WAIT_CYCLES = 8;      //地址和数据之间Dummy时钟数
//
//
//
//	t->U32_XIPCR.FRF = 2;   		//0:标准,1:双线,2四线
//	t->U32_XIPCR.INST_L = 2;		//0:没有指令,1: 4bit指令,2: 8bit指令,3:16bit指令
//	t->U32_XIPCR.ADDR_L = 6;		//0:没有地址,6: 24bit 地址 ,8:32bit 地址
//	t->U32_XIPCR.TRANS_TYPE = 2;	//命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//	t->U32_XIPCR.WAIT_CYCLES = 8;	//地址和数据之间Dummy时钟数
//
//	t->U32_XIPCR.INST_EN = 1;       //1:有指令部分 ,0:没有指令部分
//	t->U32_XIPCR.CONT_XFER_EN = 1;  //1:使能连续传输,0:关闭连续传输
//
//	t->U32_XIPCR.MD_BITS_EN = 0;    //Mode bits enable in XIP mode.
////	t->U32_XIPCR.XIP_MBL = 2;		//0:2 Mode bits, 1: 4 Mode bits, 2: 8 Mode bits , 3: 16 Mode bits
//
//	t->U32_XIPCR.XIP_PREFETCH_EN = 0; //XIP 预先载入使能,开启则多读一个byte
//
//
//	t->U32_XIPIIR.INCR_INST = 0xEB;   //Flash 读取指令
//	t->XIPMBR = 0;
//	t->XIPWIR = 0x0C;
//
//	t->U32_XIPCTTOR.XTOC= 4;
////	Delay_Ms(5);
//
//	t->U32_SSIENR.SSIC_EN = 1;
//
//	CCM->QSPILKEYR = 0x23077096;
//	CCM->U32_QSPIXIPMCFR.QSPI0_DATA_ENCR_EN = 0;
//
//	*(volatile unsigned int*)(0x40010000+0x14) |= 1<< (((((int)t-0x60000000)>>28)+1)*8); //XIP Enable
//
////----------------------- 配置 XIP -----------------------
//
//	if(flag)   //跳转到外部Flash执行程序
//	{
//		*(volatile unsigned char*)(0x40010000+0x23) &= ~(1<<((((int)t - 0x60000000)>>28)+5));//硬件控制
//
//		EIC->IER=0;								//Disable All Interrupts
//		WDT->WMR =0x0;							//Close WDT
//		WDT->WCR =0x0;
//
//		start_addr = *((volatile unsigned int*)addr);
//		LTPrintf("start addr:%x\r\n",start_addr);
//
//		LTPrintf("jump\r\n");
//		((void (*)(void))((unsigned int*)start_addr))();
//
//		while(1);
//	}
//	else
//	{
//	#if CS
//		*(volatile unsigned char*)(0x40010000+0x23) |=(1<<((((int)t - 0x60000000)>>28)+5)); //软件控制
//	#else
//		*(volatile unsigned char*)(0x40010000+0x23) &= ~(1<<((((int)t - 0x60000000)>>28)+5));//硬件控制
//	#endif
//
//	#if CS
//		QSPI_SS_LOW((int)t);
//	#endif
//
//		EPORT0->U8_EPDR.Pin_7 = 0;
//		for(i=0; i<256; i++)
//		{
////		   LTPrintf("%x ", *(unsigned char *)(addr+i));
//		   Flash_buff_RX[i] = *(unsigned char *)(addr+i);
//		}
//		EPORT0->U8_EPDR.Pin_7 = 1;
//
//
//	#if CS
//		QSPI_SS_HIGH((int)t);
//	#endif
//	//----------------------- Flash 退出QPI -----------------------
//	//	CCM->U32_QSPIXIPMCFR.QSPI0_XIPEN = 0;  //关闭XIP
//		*(volatile unsigned int*)(0x40010000+0x14) &= ~(1<< ((((int)t-0x60000000)>>28)+1)*8); //XIP Disable
//
//	//QSPI0 配置为 QPI只写
//		t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//		t->CTRLR1 = 0x00;			  //NDF = 0;
//		t->CTRLR0 = 0x00800407;// QUAD 只写 数据8bit
//		t->SPICTRLR0 = 0x40000202|(6<<11);
//		t->BAUDR = 4;
//		t->U32_SSIENR.SSIC_EN = 1;
//
//	#if CS
//		QSPI_SS_LOW((int)t);
//	#endif
//
//		t->DR = 0xFF;				//Exit QPI mode
//		__asm("nop");__asm("nop");__asm("nop");
//
//		while(t->U32_SR.TFE == 0){__asm("nop");}
//		while(t->U32_SR.BUSY == 1){__asm("nop");}
//	#if CS
//		QSPI_SS_HIGH((int)t);
//	#endif
//	//----------------------- Flash 退出QPI -----------------------
//	}
//
//}

//void Write_to_Flash(qspi* t, unsigned char* p)
//{
//	uint32_t num = 0,temp = 0;
//	UINT32 CRC1 = 0,CRC2 = 0;
//	Make_CRC32_Table();
//
//	//QSPI0 配置为 QPI只写
//		t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//		t->CTRLR1 = 0x00;			  //NDF = 0;
//		t->CTRLR0 = 0x00800407;// QUAD 只写 数据8bit
//		t->SPICTRLR0 = 0x40000202|(6<<11);
//		t->BAUDR = 4;
//		t->U32_SSIENR.SSIC_EN = 1;
//
//		t->DR = 0xFF;				//Exit QPI mode
//		__asm("nop");__asm("nop");__asm("nop");
//
//		while(t->U32_SR.TFE == 0){__asm("nop");}
//		while(t->U32_SR.BUSY == 1){__asm("nop");}
//
//	LTPrintf("app_data to NorFlash\r\n");
//	LTPrintf("app_data_num:%d \r\n",app_data_num);
////-------------------------------------------------------------------------------------------------------
//	QSPI_Standard_Init(t);  //QSPI0 单线初始化
//
//	LTPrintf("%x \r\n",W25Q_ReadID_STD(t)); //输出外挂Flash ID号 确认是否正确连接外挂Flash
//
//	W25QXX_Open_QUAD(t);
//	W25Q_BlockErase64KB_STD(t,0);	//擦除第一个Block(64KByte)
//
//	W25QXX_Write_NoCheck(t,(unsigned char*)p,0,app_data_num,1);  //四线写数据
//
//	while(num <app_data_num)
//	{
//		if(app_data_num-num>=512)
//			temp = 512;
//		else
//			temp = app_data_num-num;
//
//		W25Q_Read_STD(t,Flash_buff_RX,num,temp);
//		CRC2 = GetCrc32(Flash_buff_RX,temp,CRC2);
//		num += temp;
//	}
//
//	CRC1 = GetCrc32(p,app_data_num,0);
//	LTPrintf("CRC1:%x\r\nCRC2:%x\r\n",CRC1,CRC2);
//
//	if( CRC1!= CRC2)
//		LTPrintf("Write Fail\r\n");
//	else
//		LTPrintf("Write OK\r\n");
//}

//unsigned char XIP_buff[65536];

//void QSPI_XIP_TO_SDRAM(qspi* t)//  256K.bin CRC:0xe671e4ac
//{
//	UINT32 CRC1 = 0,CRC2 = 0;
//	UINT32 i = 0,j = 0;
////	UINT32 addr;
//
//	Make_CRC32_Table();
//
//	QSPI_Standard_Init(t);
//	W25QXX_Open_QUAD(t);
//	W25QXX_Output_Driver_Strength(t);
//
//	W25QXX_Enter_QPI_STD(t);   //Flash 进入QPI模式
//
////---------------- 配置 Read Parameters ------------------
//
//	t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//	t->CTRLR1 = 0x00;			  //NDF = 0;
//
//	t->U32_CTRLR0.SPI_FRF = 0x02;  //0:STD, 1:Dual,2:Quad
//	t->U32_CTRLR0.CFS = 0x00;	   //Microwire frame format. 此模式不用，不管
//	t->U32_CTRLR0.SSTE = 0x00;	   //不管
//	t->U32_CTRLR0.SRL = 0x00;	   //不管
//	t->U32_CTRLR0.SLV_OE = 0x00;   //不管
//	t->U32_CTRLR0.TMOD = 0x01;	   //0：全双工，1：只发，2只读
//	t->U32_CTRLR0.SCPOL = 0x00;	   //SPI00
//	t->U32_CTRLR0.SCPH = 0x00;	   //SPI00
//	t->U32_CTRLR0.FRF = 0x00;	   //0:Motorola SPI
//	t->U32_CTRLR0.DFS = 0x07;	   //7: 8bit数据传输
//
//	t->BAUDR = 4;				   //测试先用4分频
//
//	t->U32_SPICTRLR0.ADDR_L = 0;		   //0:没有地址,6: 24bit 地址 ,8:32bit 地址
//	t->U32_SPICTRLR0.CLK_STRETCH_EN = 1;   //时钟增强
//	t->U32_SPICTRLR0.INST_L = 0x02;		   //0:没有指令,1: 4bit指令,2: 8bit指令,3:16bit指令
//	t->U32_SPICTRLR0.TRANS_TYPE = 0x02;	   //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//	t->U32_SPICTRLR0.WAIT_CYCLES = 8;      //地址和数据之间Dummy时钟数
//
//	t->U32_SSIENR.SSIC_EN = 1;
//
//	*(volatile unsigned char*)(0x40010000+0x23) &= ~(1<<((((int)t - 0x60000000)>>28)+5));//硬件控制
//
//	t->DR = 0xC0;			//Set Read Parameters
//	t->DR = 0x31;			//8 dummy clocks,8 byte wrap length
//	__asm("nop");__asm("nop");__asm("nop");
//
//	while(t->U32_SR.TFE == 0) {__asm("nop");}
//	while(t->U32_SR.BUSY == 1){__asm("nop");}
//
//	//----------------------- 配置 XIP -----------------------
//
//		t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//
//		t->U32_CTRLR0.SPI_FRF = 0x02;  //0:STD, 1:Dual,2:Quad
//		t->U32_CTRLR0.CFS = 0x00;	   //Microwire frame format. 此模式不用，不管
//		t->U32_CTRLR0.SSTE = 0x00;	   //不管
//		t->U32_CTRLR0.SRL = 0x00;	   //不管
//		t->U32_CTRLR0.SLV_OE = 0x00;   //不管
//		t->U32_CTRLR0.TMOD = 0x02;	   //0：全双工，1：只发，2只读
//		t->U32_CTRLR0.SCPOL = 0x00;	   //SPI00
//		t->U32_CTRLR0.SCPH = 0x00;	   //SPI00
//		t->U32_CTRLR0.FRF = 0x00;	   //0:Motorola SPI
//		t->U32_CTRLR0.DFS = 0x1F;	   //7: 8bit数据传输,0x1F: 32bit
//
//		t->U32_RXFTLR.RFT = 0;
//
//		t->BAUDR = 4;				   //FPGA只能用4分频,
//
//		t->U32_SPICTRLR0.ADDR_L = 0x06;		   //0:没有地址,6: 24bit 地址 ,8:32bit 地址
//		t->U32_SPICTRLR0.CLK_STRETCH_EN = 1;   //时钟增强
//		t->U32_SPICTRLR0.INST_L = 0x02;		   //0:没有指令,1: 4bit指令,2: 8bit指令,3:16bit指令
//		t->U32_SPICTRLR0.TRANS_TYPE = 0x02;	   //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//		t->U32_SPICTRLR0.WAIT_CYCLES = 8;      //地址和数据之间Dummy时钟数
//
//
//
//		t->U32_XIPCR.FRF = 2;   		//0:标准,1:双线,2四线
//		t->U32_XIPCR.INST_L = 2;		//0:没有指令,1: 4bit指令,2: 8bit指令,3:16bit指令
//		t->U32_XIPCR.ADDR_L = 6;		//0:没有地址,6: 24bit 地址 ,8:32bit 地址
//		t->U32_XIPCR.TRANS_TYPE = 2;	//命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//		t->U32_XIPCR.WAIT_CYCLES = 8;	//地址和数据之间Dummy时钟数
//		t->U32_XIPCR.MD_BITS_EN = 0;    //Mode bits enable in XIP mode.
//		t->U32_XIPCR.INST_EN = 1;       //1:有指令部分 ,0:没有指令部分
//		t->U32_XIPCR.CONT_XFER_EN = 1;  //1:使能连续传输,0:关闭连续传输
//		t->U32_XIPCR.XIP_MBL = 2;		//0:2 Mode bits, 1: 4 Mode bits, 2: 8 Mode bits , 3: 16 Mode bits
//		t->U32_XIPCR.XIP_PREFETCH_EN = 0; //XIP 预先载入使能,开启则多读一个byte
//
//
//		t->U32_XIPIIR.INCR_INST = 0xEB;   //Flash 读取指令
//		t->XIPMBR = 0;
//		t->XIPWIR = 0x0C;
//	//	Delay_Ms(5);
//
//		t->U32_SSIENR.SSIC_EN = 1;
//
//	//	CCM->U32_QSPIXIPMCFR.QSPI0_ARRANGE_DATA_ON = 1;
//	//	CCM->U32_QSPIXIPMCFR.QSPI0_XIPEN = 0;
//
//		*(volatile unsigned int*)(0x40010000+0x14) |= 1<< (((((int)t-0x60000000)>>28)+1)*8); //XIP Enable
//
//	//----------------------- 配置 XIP -----------------------
//
//
//
////	for(i = 0;i < 4 ;i++)
////	{
////		for(j = 0 ;j<65536;j++)
////			XIP_buff[j] = *(unsigned char *)(0x80000000 +i*65536 + j);
////		for(j = 0 ;j<65536;j++)
////			*(unsigned char *)(0x840000 + i*65536 + j) = XIP_buff[j];
////	}
////
////	for(i = 0;i<4;i++)
////	{
////		for(j = 0 ;j<65536;j++)
////			XIP_buff[j] = *(unsigned char *)(0x840000 + i*65536 + j);
////		CRC1 = GetCrc32(XIP_buff,65536,CRC1);
////	}
//	for(i = 0;i<16;i++)
//		LTPrintf("%x ",*(unsigned char *)(0x80000000 + i));
//
////	LTPrintf("CRC1:%x \r\n",CRC1);
//	LTPrintf("\r\n");
////	LTPrintf("CRC1:%x \r\n",CRC1);
//
//
//
//	//----------------------- Flash 退出QPI -----------------------
//		//	CCM->U32_QSPIXIPMCFR.QSPI0_XIPEN = 0;  //关闭XIP
//			*(volatile unsigned int*)(0x40010000+0x14) &= ~(1<< ((((int)t-0x60000000)>>28)+1)*8); //XIP Disable
//
//		//QSPI0 配置为 QPI只写
//			t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//			t->CTRLR1 = 0x00;			  //NDF = 0;
//			t->CTRLR0 = 0x00800407;// QUAD 只写 数据8bit
//			t->SPICTRLR0 = 0x40000202|(6<<11);
//			t->BAUDR = 4;
//			t->U32_SSIENR.SSIC_EN = 1;
//
//		#if CS
//			QSPI_SS_LOW((int)t);
//		#endif
//
//			t->DR = 0xFF;				//Exit QPI mode
//			__asm("nop");__asm("nop");__asm("nop");
//
//			while(t->U32_SR.TFE == 0){__asm("nop");}
//			while(t->U32_SR.BUSY == 1){__asm("nop");}
//		#if CS
//			QSPI_SS_HIGH((int)t);
//		#endif
//		//----------------------- Flash 退出QPI -----------------------
//}

//void QSPI_QUAD_XIP_Test(qspi *t,unsigned char flag)
//{
//	UINT16 i = 0,j = 0 ;
//	UINT32 CRC;
//	uint32_t start_addr = 0;
//	UINT32 addr = 0;
//
//	addr = (UINT32)t;
//	Make_CRC32_Table();
//
//	QSPI_Standard_Init(t);
//	LTPrintf("ID:%x \r\n",W25Q_ReadID_STD(t));
//	W25QXX_Output_Driver_Strength(t);
//	W25QXX_Open_QUAD(t);
//
//#if 0
//	QSPI_Standard_Init(t);
//
//	LTPrintf("ID:%x \r\n",W25Q_ReadID_STD(t));
//
//	W25Q_BlockErase64KB_STD(t,0);
//
//	W25QXX_Write_NoCheck(t,(unsigned char*)data,0,256,1);
//
//	W25Q_Read_STD(t,Flash_buff_RX,0,256);
//	CRC = GetCrc32((unsigned char*)data,256,0);
//	LTPrintf("CRC:%x\r\n",CRC);
//	if(CRC == 0x707a0a43)
//		LTPrintf("写入OK\r\n");
//	else
//		LTPrintf("写入失败\r\n");
//#endif
//
//
//	//----------------------- 配置 XIP -----------------------
//
//	t->U32_SSIENR.SSIC_EN = 0;    //关闭SSI
//
//	t->U32_CTRLR0.SPI_FRF = 0x00;  //0:STD, 1:Dual,2:Quad
//	t->U32_CTRLR0.CFS = 0x00;	   //Microwire frame format. 此模式不用，不管
//	t->U32_CTRLR0.SSTE = 0x00;	   //不管
//	t->U32_CTRLR0.SRL = 0x00;	   //不管
//	t->U32_CTRLR0.SLV_OE = 0x00;   //不管
//	t->U32_CTRLR0.TMOD = 0x02;	   //0：全双工，1：只发，2只读
//	t->U32_CTRLR0.SCPOL = 0x00;	   //SPI00
//	t->U32_CTRLR0.SCPH = 0x00;	   //SPI00
//	t->U32_CTRLR0.FRF = 0x00;	   //0:Motorola SPI
//	t->U32_CTRLR0.DFS = 0x07;	   //7: 8bit数据传输,0x1F: 32bit
////
////	t->U32_RXFTLR.RFT = 0;
//
//	t->BAUDR = 8;				   //FPGA只能用4分频
//
////	t->U32_SPICTRLR0.ADDR_L = 0x06;		   //0:没有地址,6: 24bit 地址 ,8:32bit 地址
////	t->U32_SPICTRLR0.CLK_STRETCH_EN = 1;   //时钟增强
////	t->U32_SPICTRLR0.INST_L = 0x02;		   //0:没有指令,1: 4bit指令,2: 8bit指令,3:16bit指令
////	t->U32_SPICTRLR0.TRANS_TYPE = 0x01;	   //命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
////	t->U32_SPICTRLR0.WAIT_CYCLES = 6;      //地址和数据之间Dummy时钟数
//
////BB,W:4;  EB,W:6
//
//	t->U32_XIPCR.FRF = 1;   		//0:标准,1:双线,2四线
//	t->U32_XIPCR.INST_L = 2;		//0:没有指令,1: 4bit指令,2: 8bit指令,3:16bit指令
//	t->U32_XIPCR.ADDR_L = 6;		//0:没有地址,6: 24bit 地址 ,8:32bit 地址
//	t->U32_XIPCR.TRANS_TYPE = 0;	//命令和地址的传输类型 0:都单线，  1:命令单线、地址按配置，2:命令和地址都按配置
//	t->U32_XIPCR.WAIT_CYCLES = 8;	//地址和数据之间Dummy时钟数
//	t->U32_XIPCR.MD_BITS_EN = 0;    //Mode bits enable in XIP mode.
//	t->U32_XIPCR.INST_EN = 1;       //1:有指令部分 ,0:没有指令部分
//	t->U32_XIPCR.CONT_XFER_EN = 1;  //1:使能连续传输,0:关闭连续传输
//	t->U32_XIPCR.XIP_MBL = 0;		//0:2 Mode bits, 1: 4 Mode bits, 2: 8 Mode bits , 3: 16 Mode bits
//	t->U32_XIPCR.XIP_PREFETCH_EN = 0; //XIP 预先载入使能,开启则多读一个byte
//
//	t->RXSDR = 0;
//	t->U32_XIPIIR.INCR_INST = 0x3B;   //Flash 读取指令
//	t->XIPMBR = 0;
//	t->XIPWIR = 0x3B;
//
//	t->U32_XIPCTTOR.XTOC= 16;
////	Delay_Ms(5);
//
//	t->U32_SSIENR.SSIC_EN = 1;
//
//#if !CS
//	*(volatile unsigned char*)(0x40010000+0x23) &= ~(1<<((((int)t - 0x60000000)>>28)+5));//硬件控制
//#else
//	*(volatile unsigned char*)(0x40010000+0x23) |= (1<<((((int)t - 0x60000000)>>28)+5)); //软件控制
//#endif
//
//
//	CCM->QSPILKEYR = 0x23077096;
//	CCM->U32_QSPIXIPMCFR.QSPI0_DATA_ENCR_EN = 0;
//
//	*(volatile unsigned int*)(0x40010000+0x14) |= 1<< (((((int)t-0x60000000)>>28)+1)*8); //XIP Enable
//
//		//----------------------- 配置 XIP -----------------------
//	if(flag)   //跳转到外部Flash执行程序
//	{
//
//		EIC->IER=0;								//Disable All Interrupts
//		WDT->WMR =0x0;							//Close WDT
//		WDT->WCR =0x0;
//
//		CACHE->LMEM_ACRG = 0;
//		CACHE->U32_LMEM_CCR.ENCACHE = 0;
//
//		start_addr = *((volatile unsigned int*)addr);
//		LTPrintf("start addr:%x\r\n",start_addr);
//
//		LTPrintf("jump\r\n");
//		((void (*)(void))((unsigned int*)start_addr))();
//
//		while(1){__asm("nop");};
//	}
//	else
//	{
//		for(j = 0;j<1;j++)
//		{
////			EPORT0->U8_EPDR.Pin_7 = 0;
//			for(i = 0;i<1637;i++)
//				LTPrintf("%x ", *(unsigned char *)(((UINT32)t) + 0 + i));
////				Flash_buff_RX[i] = *(unsigned char *)(addr + i);
////			EPORT0->U8_EPDR.Pin_7 = 1;
//		}
////		CRC = GetCrc32((unsigned char*)Flash_buff_RX,256,0);
////		LTPrintf("CRC:%x\r\n",CRC);
////		if(CRC == 0x707a0a43)
////			LTPrintf("OK\r\n");
////		else
////			LTPrintf("失败\r\n");
//
//	}
//}
void QSPI0_Handler(void)
{
	LTPrintf("QSPI0_Handler\r\n");
}

void QSPI1_Handler(void)
{
	LTPrintf("QSPI1_Handler\r\n");
}

void QSPI2_Handler(void)
{
	unsigned char temp;
	LTPrintf("QSPI2_Handler\r\n");
	temp = QSPI2->ISR;

	LTPrintf("SR:%x\r\n",QSPI2->SR);
	LTPrintf("ISR:%x\r\n",temp);
	LTPrintf("R:%d\r\n",QSPI2->U32_RXFLR.RXTFL);
	LTPrintf("T:%d\r\n",QSPI2->U32_TXFLR.TXTFL);

	if((temp&0x10) == 0x10)  //发送FIFO满
	{
		for(;(temp&0x10) == 0x10;)
			QSPI2->DR;
	}
	if((temp&0x02) == 0x02)  //TX FIFO Overflow
	{
		QSPI2->U32_TXOICR.TXOICR;
	}
	if((temp&0x04) == 0x04)  //RX FIFO Underflow
	{
		QSPI2->U32_RXUICR.RXUICR;
	}



}

void QSPI_INT_Test(qspi *t)
{
	unsigned short i = 0;

	EIC->U32_IER.IE_QSPI0 = 1;
	EIC->U32_IER.IE_QSPI1 = 1;
	EIC->U32_IER.IE_QSPI2 = 1;

	t->U32_SSIENR.SSIC_EN = 0;  //失能QSPI0

	t->U32_CTRLR0.SPI_FRF = 0;  //标准SPI模式
	t->U32_CTRLR0.CFS = 0;		//
	t->U32_CTRLR0.SSTE = 0;		//
	t->U32_CTRLR0.SRL = 0;		//
	t->U32_CTRLR0.SLV_OE = 0;	//
	t->U32_CTRLR0.TMOD = 2;		//TX_AND_RX
	t->U32_CTRLR0.SCPOL = 0;	//闲置为高电平
	t->U32_CTRLR0.SCPH = 0;		//数据抓取从一个时钟周期的第二个边沿开始
	t->U32_CTRLR0.FRF = 0;		//摩托罗拉SPI模式
	t->U32_CTRLR0.DFS = 0x07;   //数据格式为8bit

//	LTPrintf("CTRLR0:%x \r\n",t->U32_CTRLR0);

	t->U32_CTRLR1.NDF = 0;		//传输数目
	t->U32_BAUDR.SCKDV = 8;  	//时钟频率
	t->U32_TXFTLR.TXFTHR = 0;   //转移开始FIFO等级
	t->U32_TXFTLR.TFT = 9;		//传输FIFO阈值
	t->U32_RXFTLR.RFT = 8;		//接受FIFO阈值

	t->U32_RXSDR.SE = 0;		//
	t->U32_RXSDR.RSD = 0;		//接收数据采样延迟

	t->U32_SPICTRLR0.CLK_STRETCH_EN = 0; //SPI时钟增强
	t->U32_SPICTRLR0.WAIT_CYCLES = 0;	 //等待周期
	t->U32_SPICTRLR0.INST_L = 0x02;		 //命令长度
	t->U32_SPICTRLR0.ADDR_L = 0x06;		 //地址长度
	t->U32_SPICTRLR0.TRANS_TYPE = 0;   //命令和地址的传输类型

	t->U32_SSIENR.SSIC_EN = 1;  //使能QSPI0

//------片选部分-------

	if(t == QSPI0)
	{
		CCM->U32_QSPIGPIOCR.QSPI0_SS_GPIOPEN = 1; //片选软件控制
		CCM->U32_QSPIGPIOCR.QSPI0_SS_PUE = 1;//片选上拉
		CCM->U32_QSPIGPIOCR.QSPI0_SS_OBE = 1;//输出模式
	}
	else if(t == QSPI1)
	{
		CCM->U32_QSPIGPIOCR.QSPI1_SS_GPIOPEN = 1; //片选软件控制
		CCM->U32_QSPIGPIOCR.QSPI1_SS_PUE = 1;//片选上拉
		CCM->U32_QSPIGPIOCR.QSPI1_SS_OBE = 1;//输出模式
	}
	else if(t == QSPI2)
	{
		CCM->U32_QSPIGPIOCR.QSPI2_SS_GPIOPEN = 1; //片选软件控制
		CCM->U32_QSPIGPIOCR.QSPI2_SS_PUE = 1;//片选上拉
		CCM->U32_QSPIGPIOCR.QSPI2_SS_OBE = 1;//输出模式
	}

	QSPI_SS_HIGH((int)t);

	QSPI_SS_LOW((int)t);

//	for(i = 0;i<10;i++)
//	{
		t->DR;
//	}

    QSPI_SS_HIGH((int)t);

    while(1);
}

//void QSPI_Test(void)
//{
//	Eport0_7(OUTPUT);
//
//	OPTION->U16_CCR.CCRTEST = 1;
//	OPTION->U16_CCR.CCRTEST = 2;
//	OPTION->U16_CCR.CCRTEST = 3;
//	OPTION->U16_CCR.QSPI2EN = 1;   //use QSPI2,Close PWM
//
////	QSPI_INT_Test(QSPI0);
//
////	QSPI_STD_NoDMA_Test(QSPI0);
//
////	QSPI_Dual_NoDMA_Test(QSPI2);
//
////	QSPI_Quad_NoDMA_Test(QSPI2);
//
////	QSPI_Dual_DMA_Test(QSPI0);
//
////	QSPI_Quad_DMA_Test(QSPI0);
//
////	Write_to_Flash(QSPI0,app_data);  //OK 2022-4-07
//
////	QSPI_XIP_Test(QSPI0,1);   //0: XIP读数据，1:跑外部Flash程序
//
////	QSPI_XIP_TO_SDRAM(QSPI2);  //
//
//	QSPI_QUAD_XIP_Test(QSPI0,1);  //2022-04-29 0: XIP读数据，1:跑外部Flash程序
//
//	while(1)
//	{
////		Delay_Ms(100);
//	}
//}

void QSPI_Demo(void)
{
//	RGB_Init();
//	LCD_BL_Init();
	QSPI_Standard_Init(QSPI1);  //QSPI0 单线初始化
	W25QXX_Open_QUAD(QSPI1);
	QSPI_Quad_Init(QSPI1,CS);   //Quad Read Command 6BH
	//	W25QXX_Output_Driver_Strength(t);    //Flash 输出能力
	while(1)
	{
//		LTPrintf("Picture1\r\n");
		EPORT0->EPDR |= 0x10;
		LT168_Display_Picture(0,0,480,272,0);
		Delay_Ms(1000);
//		LTPrintf("Picture2\r\n");
		EPORT0->EPDR &=~0x10;
		LT168_Display_Picture(0,0,480,270,0x0003fc00);
		Delay_Ms(1000);
		LT168_Display_Picture(50,1,270,270,0x0007f080);
		Delay_Ms(1000);
		LT168_Display_Picture(200,70,205,146,0x000a2a08);
		Delay_Ms(1000);
	}
}


//------------------------------------ QPI drive ------------------------------------



